﻿using System.Runtime.InteropServices;

public static partial class gl
{
    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double funpqv(IntPtr x_ptr, IntPtr b_ptr, int n, double t);

    public static unsafe double funpqv(double[] x, double[] b, int n, double t)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        return funpqv(x_ptr, b_ptr, n, t);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void funpqj(IntPtr x_ptr, IntPtr y_ptr, IntPtr b_ptr, int j);

    public static unsafe void funpqj(double[] x, double[] y, double[] b, int j)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        funpqj(x_ptr, y_ptr, b_ptr, j);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int trch(IntPtr t_ptr, IntPtr tt_ptr, int n, IntPtr b_ptr);

    public static unsafe int trch(double[] t, double[] tt, int n, double[,] b)
    {
        IntPtr t_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(t, 0);
        IntPtr tt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(tt, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        return trch(t_ptr, tt_ptr, n, b_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int maqr(IntPtr a_ptr, int m, int n, IntPtr q_ptr);

    public static unsafe int maqr(double[,] a, int m, int n, double[,] q)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        return maqr(a_ptr, m, n, q_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int muav(IntPtr a_ptr, int m, int n, IntPtr u_ptr, IntPtr v_ptr, double eps, int ka, int inter);

    public static unsafe int muav(double[,] a, int m, int n, double[,] u, double[,] v, double eps, int ka, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr u_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(u, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return muav(a_ptr, m, n, u_ptr, v_ptr, eps, ka, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int ssgj(IntPtr a_ptr, int n);

    public static unsafe int ssgj(double[,] a, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        return ssgj(a_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int chol(IntPtr a_ptr, int n);

    public static unsafe int chol(double[,] a, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        return chol(a_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int ginv(IntPtr a_ptr, int m, int n, IntPtr aa_ptr, double eps, IntPtr u_ptr, IntPtr v_ptr, int ka, int inter = 100);

    public static unsafe int ginv(double[,] a, int m, int n, double[,] aa, double eps, double[,] u, double[,] v, int ka, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr aa_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(aa, 0);
        IntPtr u_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(u, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return ginv(a_ptr, m, n, aa_ptr, eps, u_ptr, v_ptr, ka, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int rank(IntPtr a_ptr, int m, int n);

    public static unsafe int rank(double[,] a, int m, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        return rank(a_ptr, m, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int inv(IntPtr a_ptr, int n);

    public static unsafe int inv(double[,] a, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        return inv(a_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int lluu(IntPtr a_ptr, int n, IntPtr l_ptr, IntPtr u_ptr);

    public static unsafe int lluu(double[,] a, int n, double[,] l, double[,] u)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr l_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(l, 0);
        IntPtr u_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(u, 0);
        return lluu(a_ptr, n, l_ptr, u_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double sdet(IntPtr a_ptr, int n);

    public static unsafe double sdet(double[,] a, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        return sdet(a_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int jacobi(IntPtr a_ptr, int n, IntPtr v_ptr, double eps, int inter);

    public static unsafe int jacobi(double[,] a, int n, double[,] v, double eps, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return jacobi(a_ptr, n, v_ptr, eps, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int jcbj(IntPtr a_ptr, int n, IntPtr v_ptr, double eps);

    public static unsafe int jcbj(double[,] a, int n, double[,] v, double eps)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return jcbj(a_ptr, n, v_ptr, eps);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double power(int n, IntPtr a_ptr, double eps, IntPtr v_ptr, int inter);

    public static unsafe double power(int n, double[,] a, double eps, double[] v, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return power(n, a_ptr, eps, v_ptr, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int hhqr(IntPtr a_ptr, int n, IntPtr u_ptr, IntPtr v_ptr, double eps, int inter);

    public static unsafe int hhqr(double[,] a, int n, double[] u, double[] v, double eps, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr u_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(u, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return hhqr(a_ptr, n, u_ptr, v_ptr, eps, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int sstq(int n, IntPtr b_ptr, IntPtr c_ptr, IntPtr q_ptr, double eps, int inter);

    public static unsafe int sstq(int n, double[] b, double[] c, double[,] q, double eps, int inter)
    {
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr c_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(c, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        return sstq(n, b_ptr, c_ptr, q_ptr, eps, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void hhbg(IntPtr a_ptr, int n);

    public static unsafe void hhbg(double[,] a, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        hhbg(a_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int strq(IntPtr a_ptr, int n, IntPtr q_ptr, IntPtr b_ptr, IntPtr c_ptr);

    public static unsafe int strq(double[,] a, int n, double[,] q, double[] b, double[] c)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr c_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(c, 0);
        return strq(a_ptr, n, q_ptr, b_ptr, c_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int gauss_jordan(IntPtr a_ptr, IntPtr b_ptr, int n);

    public static unsafe int gauss_jordan(double[,] a, double[] b, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        return gauss_jordan(a_ptr, b_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int gauss(IntPtr a_ptr, IntPtr b_ptr, int n);

    public static unsafe int gauss(double[,] a, double[] b, int n)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        return gauss(a_ptr, b_ptr, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int seidel(IntPtr a_ptr, IntPtr b_ptr, int n, IntPtr x_ptr, double eps);

    public static unsafe int seidel(double[,] a, double[] b, int n, double[] x, double eps)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        return seidel(a_ptr, b_ptr, n, x_ptr, eps);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int tlvs(IntPtr t_ptr, int n, IntPtr b_ptr, IntPtr x_ptr);

    public static unsafe int tlvs(double[] t, int n, double[] b, double[] x)
    {
        IntPtr t_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(t, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        return tlvs(t_ptr, n, b_ptr, x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int band(IntPtr b_ptr, IntPtr d_ptr, int n, int l, int il, int m);

    public static unsafe int band(double[,] b, double[,] d, int n, int l, int il, int m)
    {
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr d_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(d, 0);
        return band(b_ptr, d_ptr, n, l, il, m);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int trde(IntPtr b_ptr, int n, int m, IntPtr d_ptr);

    public static unsafe int trde(double[] b, int n, int m, double[] d)
    {
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr d_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(d, 0);
        return trde(b_ptr, n, m, d_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void grad(IntPtr a_ptr, int n, IntPtr b_ptr, double eps, IntPtr x_ptr);

    public static unsafe void grad(double[,] a, int n, double[] b, double eps, double[] x)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        grad(a_ptr, n, b_ptr, eps, x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int ldle(IntPtr a_ptr, int n, int m, IntPtr c_ptr);

    public static unsafe int ldle(double[,] a, int n, int m, double[,] c)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr c_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(c, 0);
        return ldle(a_ptr, n, m, c_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int chlk(IntPtr a_ptr, int n, int m, IntPtr d_ptr);

    public static unsafe int chlk(double[,] a, int n, int m, double[,] d)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr d_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(d, 0);
        return chlk(a_ptr, n, m, d_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int bingt(IntPtr a_ptr, int n, IntPtr b_ptr, double eps, IntPtr x_ptr, int inter);

    public static unsafe int bingt(double[,] a, int n, double[] b, double eps, double[] x, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        return bingt(a_ptr, n, b_ptr, eps, x_ptr, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void tmul(IntPtr a_ptr, int ma, int na, IntPtr b_ptr, int mb, int nb, IntPtr c_ptr);

    public static unsafe void tmul(double[,] a, int ma, int na, double[,] b, int mb, int nb, double[,] c)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr c_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(c, 0);
        tmul(a_ptr, ma, na, b_ptr, mb, nb, c_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int gmqr(IntPtr a_ptr, int m, int n, IntPtr b_ptr, IntPtr q_ptr);

    public static unsafe int gmqr(double[,] a, int m, int n, double[] b, double[,] q)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        return gmqr(a_ptr, m, n, b_ptr, q_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int gmiv(IntPtr a_ptr, int m, int n, IntPtr b_ptr, IntPtr x_ptr, IntPtr aa_ptr, double eps, IntPtr u_ptr, IntPtr v_ptr, int ka, int inter);

    public static unsafe int gmiv(double[,] a, int m, int n, double[] b, double[] x, double[,] aa, double eps, double[,] u, double[,] v, int ka, int inter)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr aa_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(aa, 0);
        IntPtr u_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(u, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        return gmiv(a_ptr, m, n, b_ptr, x_ptr, aa_ptr, eps, u_ptr, v_ptr, ka, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int srrt(IntPtr ar_ptr, IntPtr ai_ptr, int n, IntPtr xr_ptr, IntPtr xi_ptr);

    public static unsafe int srrt(double[] ar, double[] ai, int n, double[] xr, double[] xi)
    {
        IntPtr ar_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ar, 0);
        IntPtr ai_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ai, 0);
        IntPtr xr_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xr, 0);
        IntPtr xi_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xi, 0);
        return srrt(ar_ptr, ai_ptr, n, xr_ptr, xi_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int qrrt(IntPtr a_ptr, int n, IntPtr xr_ptr, IntPtr xi_ptr, double eps);

    public static unsafe int qrrt(double[] a, int n, double[] xr, double[] xi, double eps)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr xr_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xr, 0);
        IntPtr xi_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xi, 0);
        return qrrt(a_ptr, n, xr_ptr, xi_ptr, eps);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int atkn(IntPtr x_ptr, double eps, IntPtr f_x_ptr, int inter);

    public static unsafe int atkn(double[] x, double eps, int inter)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return atkn(x_ptr, eps, f_x_ptr, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int newt(IntPtr x_ptr, double eps, IntPtr f_x_ptr, IntPtr df_x_ptr, int inter);

    public static unsafe int newt(double[] x, double eps, int inter)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        IntPtr df_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(df_x);
        return newt(x_ptr, eps, f_x_ptr, df_x_ptr, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int dhrt(double a, double b, double h, double eps, IntPtr x_ptr, int m, IntPtr f_x_ptr);

    public static unsafe int dhrt(double a, double b, double h, double eps, double[] x, int m)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return dhrt(a, b, h, eps, x_ptr, m, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int fals(double a, double b, double eps, IntPtr f_x_ptr, IntPtr x_ptr);

    public static unsafe int fals(double a, double b, double eps, double[] x)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return fals(a, b, eps, f_x_ptr, x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int pqroot(IntPtr x_ptr, double eps, IntPtr f_x_ptr);

    public static unsafe int pqroot(double[] x, double eps)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return pqroot(x_ptr, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int mtcl(IntPtr zr_ptr, IntPtr zi_ptr, double b, int m, double eps, IntPtr f_x_ptr);

    public static unsafe int mtcl(double[] zr, double[] zi, double b, int m, double eps)
    {
        IntPtr zr_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(zr, 0);
        IntPtr zi_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(zi, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return mtcl(zr_ptr, zi_ptr, b, m, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double metcalo(double z, double b, int m, double eps, IntPtr f_x_ptr);

    public static unsafe double metcalo(double z, double b, int m, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return metcalo(z, b, m, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void nmtc(IntPtr x_ptr, int n, double b, int m, double eps, IntPtr f_xa_n_ptr);

    public static unsafe void nmtc(double[] x, int n, double b, int m, double eps)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_xa_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_n>(f_xa_n);
        nmtc(x_ptr, n, b, m, eps, f_xa_n_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int netn(int n, double eps, double h, IntPtr x_ptr, IntPtr f_xa_ya_n_ptr, int inter);

    public static unsafe int netn(int n, double eps, double h, double[] x, int inter)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_xa_ya_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_ya_n>(f_xa_ya_n);
        return netn(n, eps, h, x_ptr, f_xa_ya_n_ptr, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int ngin(int m, int n, double eps1, double eps2, IntPtr x_ptr, IntPtr f_xa_ya_mn_ptr, IntPtr s_xa_ya_mn_ptr);

    public static unsafe int ngin(int m, int n, double eps1, double eps2, double[] x)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_xa_ya_mn_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_ya_mn>(f_xa_ya_mn);
        IntPtr s_xa_ya_mn_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_ya_mn>(s_xa_ya_mn);
        return ngin(m, n, eps1, eps2, x_ptr, f_xa_ya_mn_ptr, s_xa_ya_mn_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int snse(int n, double eps, IntPtr x_ptr, IntPtr f_xa_ya_n_ptr, int inter);

    public static unsafe int snse(int n, double eps, double[] x, int inter)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_xa_ya_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_ya_n>(f_xa_ya_n);
        return snse(n, eps, x_ptr, f_xa_ya_n_ptr, inter);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double aitken(IntPtr x_ptr, IntPtr y_ptr, int n, double eps, double t);

    public static unsafe double aitken(double[] x, double[] y, int n, double eps, double t)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        return aitken(x_ptr, y_ptr, n, eps, t);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double hermite(IntPtr x_ptr, IntPtr y_ptr, IntPtr dy_ptr, int n, double t);

    public static unsafe double hermite(double[] x, double[] y, double[] dy, int n, double t)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr dy_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dy, 0);
        return hermite(x_ptr, y_ptr, dy_ptr, n, t);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double lagrange(IntPtr x_ptr, IntPtr y_ptr, int n, double t);

    public static unsafe double lagrange(double[] x, double[] y, int n, double t)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        return lagrange(x_ptr, y_ptr, n, t);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double remz(double a, double b, IntPtr p_ptr, int n, double eps, IntPtr f_x_ptr);

    public static unsafe double remz(double a, double b, double[] p, int n, double eps)
    {
        IntPtr p_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(p, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return remz(a, b, p_ptr, n, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double splin(int n, IntPtr x_ptr, IntPtr y_ptr, IntPtr dy_ptr, IntPtr ddy_ptr, int m, IntPtr t_ptr, IntPtr z_ptr, IntPtr dz_ptr, IntPtr ddz_ptr, int flag);

    public static unsafe double splin(int n, double[] x, double[] y, double[] dy, double[] ddy, int m, double[] t, double[] z, double[] dz, double[] ddz, int flag)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr dy_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dy, 0);
        IntPtr ddy_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ddy, 0);
        IntPtr t_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(t, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr dz_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dz, 0);
        IntPtr ddz_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ddz, 0);
        return splin(n, x_ptr, y_ptr, dy_ptr, ddy_ptr, m, t_ptr, z_ptr, dz_ptr, ddz_ptr, flag);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double slgrg(IntPtr x_ptr, IntPtr y_ptr, IntPtr z_ptr, int n, int m, double u, double v);

    public static unsafe double slgrg(double[] x, double[] y, double[,] z, int n, int m, double u, double v)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        return slgrg(x_ptr, y_ptr, z_ptr, n, m, u, v);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double akima(int n, IntPtr x_ptr, IntPtr y_ptr, double t, IntPtr s_ptr);

    public static unsafe double akima(int n, double[] x, double[] y, double t, double[] s)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr s_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(s, 0);
        return akima(n, x_ptr, y_ptr, t, s_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double chir(int n, IntPtr x_ptr, IntPtr y_ptr, int m, IntPtr a_ptr);

    public static unsafe double chir(int n, double[] x, double[] y, int m, double[] a)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        return chir(n, x_ptr, y_ptr, m, a_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void pir1(IntPtr x_ptr, IntPtr y_ptr, int n, IntPtr a_ptr, int m, IntPtr dt_ptr);

    public static unsafe void pir1(double[] x, double[] y, int n, double[] a, int m, double[] dt)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        pir1(x_ptr, y_ptr, n, a_ptr, m, dt_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void pir2(IntPtr x_ptr, IntPtr y_ptr, IntPtr z_ptr, int n, int m, IntPtr a_ptr, int p, int q, IntPtr dt_ptr);

    public static unsafe void pir2(double[] x, double[] y, double[,] z, int n, int m, double[,] a, int p, int q, double[] dt)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        pir2(x_ptr, y_ptr, z_ptr, n, m, a_ptr, p, q, dt_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double funpq(IntPtr x_ptr, IntPtr y_ptr, int n, double eps, double t);

    public static unsafe double funpq(double[] x, double[] y, int n, double eps, double t)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        return funpq(x_ptr, y_ptr, n, eps, t);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double mtcl(double a, double b, IntPtr f_x_ptr);

    public static unsafe double mtcl(double a, double b)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return mtcl(a, b, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double romb(double a, double b, double eps, IntPtr f_x_ptr);

    public static unsafe double romb(double a, double b, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return romb(a, b, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double simp(double a, double b, double eps, IntPtr f_x_ptr);

    public static unsafe double simp(double a, double b, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return simp(a, b, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double cbsv(double a, double b, double eps, IntPtr f_x_ptr);

    public static unsafe double cbsv(double a, double b, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return cbsv(a, b, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double lrgs(double a, double b, double eps, IntPtr f_x_ptr);

    public static unsafe double lrgs(double a, double b, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return lrgs(a, b, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double hmgs(IntPtr f_x_ptr);

    public static unsafe double hmgs()
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return hmgs(f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double lags(IntPtr f_x_ptr);

    public static unsafe double lags()
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return lags(f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double ffts(double a, double b, double eps, IntPtr f_x_ptr);

    public static unsafe double ffts(double a, double b, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return ffts(a, b, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double fpts(double a, double b, double eps, IntPtr f_x_ptr);

    public static unsafe double fpts(double a, double b, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return fpts(a, b, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double simp2(double a, double b, double eps, IntPtr s_x_ya_ptr, IntPtr f_xy_ptr);

    public static unsafe double simp2(double a, double b, double eps)
    {
        IntPtr s_x_ya_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya>(s_x_ya);
        IntPtr f_xy_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xy>(f_xy);
        return simp2(a, b, eps, s_x_ya_ptr, f_xy_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double pqg2(double a, double b, double eps, IntPtr s_x_ya_ptr, IntPtr f_xy_ptr);

    public static unsafe double pqg2(double a, double b, double eps)
    {
        IntPtr s_x_ya_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya>(s_x_ya);
        IntPtr f_xy_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xy>(f_xy);
        return pqg2(a, b, eps, s_x_ya_ptr, f_xy_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double mtml(int n, IntPtr a_ptr, IntPtr b_ptr, IntPtr f_xa_n_ptr);

    public static unsafe double mtml(int n, double[] a, double[] b)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr f_xa_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_n>(f_xa_n);
        return mtml(n, a_ptr, b_ptr, f_xa_n_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double gaus_int(int n, IntPtr js_ptr, IntPtr s_xa_ya_mn_ptr, IntPtr f_xa_n_ptr);

    public static unsafe double gaus_int(int n, int[] js)
    {
        IntPtr js_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(js, 0);
        IntPtr s_xa_ya_mn_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_ya_mn>(s_xa_ya_mn);
        IntPtr f_xa_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_n>(f_xa_n);
        return gaus_int(n, js_ptr, s_xa_ya_mn_ptr, f_xa_n_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double pqinteg(double a0, double b0, double eps, IntPtr f_x_ptr);

    public static unsafe double pqinteg(double a0, double b0, double eps)
    {
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        return pqinteg(a0, b0, eps, f_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void part(double a, double b, int m, int n, IntPtr fa_ptr, IntPtr fb_ptr, IntPtr s_ptr);

    public static unsafe void part(double a, double b, int m, int n, double[] fa, double[] fb, double[] s)
    {
        IntPtr fa_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(fa, 0);
        IntPtr fb_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(fb, 0);
        IntPtr s_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(s, 0);
        part(a, b, m, n, fa_ptr, fb_ptr, s_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void adams(double t, double h, int n, IntPtr y_ptr, double eps, int k, IntPtr z_ptr, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void adams(double t, double h, int n, double[] y, double eps, int k, double[,] z)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        adams(t, h, n, y_ptr, eps, k, z_ptr, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void hamming(double t, double h, int n, IntPtr y_ptr, double eps, int k, IntPtr z_ptr, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void hamming(double t, double h, int n, double[] y, double eps, int k, double[,] z)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        hamming(t, h, n, y_ptr, eps, k, z_ptr, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void gjfq(double t, double h, int n, IntPtr y_ptr, double eps, int k, IntPtr z_ptr, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void gjfq(double t, double h, int n, double[] y, double eps, int k, double[,] z)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        gjfq(t, h, n, y_ptr, eps, k, z_ptr, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void euler(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void euler(double t, double h, int n, double[] y, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        euler(t, h, n, y_ptr, eps, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void gill(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr q_ptr, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void gill(double t, double h, int n, double[] y, double eps, double[] q)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        gill(t, h, n, y_ptr, eps, q_ptr, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void merson(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void merson(double t, double h, int n, double[] y, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        merson(t, h, n, y_ptr, eps, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void runge_kutta(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void runge_kutta(double t, double h, int n, double[] y, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        runge_kutta(t, h, n, y_ptr, eps, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void treanor(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void treanor(double t, double h, int n, double[] y, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        treanor(t, h, n, y_ptr, eps, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void witty(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void witty(double t, double h, int n, double[] y, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        witty(t, h, n, y_ptr, eps, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void pqeuler(double t, double h, int n, IntPtr y_ptr, double eps, IntPtr f_x_ya_n_da_ptr);

    public static unsafe void pqeuler(double t, double h, int n, double[] y, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        pqeuler(t, h, n, y_ptr, eps, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void euler2(double t, double h, IntPtr y_ptr, IntPtr z_ptr, double eps, IntPtr f_abc_ptr);

    public static unsafe void euler2(double t, double h, double[] y, double[] z, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr f_abc_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_abc>(f_abc);
        euler2(t, h, y_ptr, z_ptr, eps, f_abc_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void pqeuler2(double t, double h, IntPtr y_ptr, IntPtr z_ptr, double eps, IntPtr f_abc_ptr);

    public static unsafe void pqeuler2(double t, double h, double[] y, double[] z, double eps)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr f_abc_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_abc>(f_abc);
        pqeuler2(t, h, y_ptr, z_ptr, eps, f_abc_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void bound(int n, double t0, double tn, IntPtr y_ptr, IntPtr f_abcd_ptr);

    public static unsafe void bound(int n, double t0, double tn, double[] y)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_abcd_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_abcd>(f_abcd);
        bound(n, t0, tn, y_ptr, f_abcd_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double shoot(int n, double a, double b, double eps, IntPtr y_ptr, IntPtr f_abc_ptr);

    public static unsafe double shoot(int n, double a, double b, double eps, double[] y)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_abc_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_abc>(f_abc);
        return shoot(n, a, b, eps, y_ptr, f_abc_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double pqshoot(int n, double a, double b, double eps, IntPtr y_ptr, IntPtr f_abc_ptr);

    public static unsafe double pqshoot(int n, double a, double b, double eps, double[] y)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr f_abc_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_abc>(f_abc);
        return pqshoot(n, a, b, eps, y_ptr, f_abc_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int gear(double a, double b, double hmin, double hmax, double h, double eps, int n, IntPtr y0_ptr, int k, IntPtr t_ptr, IntPtr z_ptr, IntPtr ss_x_ya_n_da_ptr, IntPtr f_x_ya_n_da_ptr);

    public static unsafe int gear(double a, double b, double hmin, double hmax, double h, double eps, int n, double[] y0, int k, double[] t, double[,] z)
    {
        IntPtr y0_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y0, 0);
        IntPtr t_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(t, 0);
        IntPtr z_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(z, 0);
        IntPtr ss_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(ss_x_ya_n_da);
        IntPtr f_x_ya_n_da_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x_ya_n_da>(f_x_ya_n_da);
        return gear(a, b, hmin, hmax, h, eps, n, y0_ptr, k, t_ptr, z_ptr, ss_x_ya_n_da_ptr, f_x_ya_n_da_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void sqt1(int n, IntPtr x_ptr, IntPtr y_ptr, IntPtr a_ptr, IntPtr dt_ptr);

    public static unsafe void sqt1(int n, double[] x, double[] y, double[] a, double[] dt)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        sqt1(n, x_ptr, y_ptr, a_ptr, dt_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void log1(int n, IntPtr x_ptr, IntPtr y_ptr, double t, IntPtr a_ptr, IntPtr dt_ptr);

    public static unsafe void log1(int n, double[] x, double[] y, double t, double[] a, double[] dt)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        log1(n, x_ptr, y_ptr, t, a_ptr, dt_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void sqt2(int m, int n, IntPtr x_ptr, IntPtr y_ptr, IntPtr a_ptr, IntPtr dt_ptr, IntPtr v_ptr);

    public static unsafe void sqt2(int m, int n, double[,] x, double[] y, double[] a, double[] dt, double[] v)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        sqt2(m, n, x_ptr, y_ptr, a_ptr, dt_ptr, v_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void log2(int n, IntPtr x_ptr, IntPtr y_ptr, IntPtr a_ptr, IntPtr dt_ptr);

    public static unsafe void log2(int n, double[] x, double[] y, double[] a, double[] dt)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        log2(n, x_ptr, y_ptr, a_ptr, dt_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void sqt3(int n, int k, IntPtr x_ptr, double f1, double f2, double eps, IntPtr xx_ptr, IntPtr b_ptr, IntPtr v_ptr, IntPtr s_ptr, IntPtr dt_ptr, IntPtr ye_ptr, IntPtr yr_ptr, IntPtr r_ptr);

    public static unsafe void sqt3(int n, int k, double[,] x, double f1, double f2, double eps, double[] xx, double[] b, double[] v, double[] s, double[] dt, double[] ye, double[] yr, double[,] r)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr xx_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xx, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr v_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(v, 0);
        IntPtr s_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(s, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        IntPtr ye_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ye, 0);
        IntPtr yr_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(yr, 0);
        IntPtr r_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(r, 0);
        sqt3(n, k, x_ptr, f1, f2, eps, xx_ptr, b_ptr, v_ptr, s_ptr, dt_ptr, ye_ptr, yr_ptr, r_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void rhis(int n, IntPtr x_ptr, int m, double x0, double h, IntPtr g_ptr, IntPtr q_ptr, IntPtr dt_ptr, int k);

    public static unsafe void rhis(int n, double[] x, int m, double x0, double h, int[] g, int[] q, double[] dt, int k)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr g_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(g, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        IntPtr dt_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(dt, 0);
        rhis(n, x_ptr, m, x0, h, g_ptr, q_ptr, dt_ptr, k);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int maxn(int n, IntPtr x_ptr, double eps, IntPtr f_xa_nj_ptr);

    public static unsafe int maxn(int n, double[] x, double eps)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_xa_nj_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_nj>(f_xa_nj);
        return maxn(n, x_ptr, eps, f_xa_nj_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int max1(IntPtr x_ptr, double eps, IntPtr f_x_ptr, IntPtr df_x_ptr);

    public static unsafe int max1(double[] x, double eps)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr f_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(f_x);
        IntPtr df_x_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_x>(df_x);
        return max1(x_ptr, eps, f_x_ptr, df_x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int lplq(int m, int n, IntPtr a_ptr, IntPtr b_ptr, IntPtr c_ptr, IntPtr x_ptr);

    public static unsafe int lplq(int m, int n, double[,] a, double[] b, double[] c, double[] x)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr c_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(c, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        return lplq(m, n, a_ptr, b_ptr, c_ptr, x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int cplx(int n, int m, IntPtr a_ptr, IntPtr b_ptr, double eps, IntPtr x_ptr, IntPtr xx_ptr, IntPtr s_nm_xa_ya_ua_va_ptr, IntPtr f_xa_n_ptr, double alpha);

    public static unsafe int cplx(int n, int m, double[] a, double[] b, double eps, double[] x, double[,] xx, double alpha)
    {
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr xx_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xx, 0);
        IntPtr s_nm_xa_ya_ua_va_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_nm_xa_ya_ua_va>(s_nm_xa_ya_ua_va);
        IntPtr f_xa_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_n>(f_xa_n);
        return cplx(n, m, a_ptr, b_ptr, eps, x_ptr, xx_ptr, s_nm_xa_ya_ua_va_ptr, f_xa_n_ptr, alpha);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int jsim(int n, IntPtr x_ptr, double eps, IntPtr xx_ptr, IntPtr f_xa_n_ptr);

    public static unsafe int jsim(int n, double[] x, double eps, double[,] xx)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr xx_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(xx, 0);
        IntPtr f_xa_n_ptr = Marshal.GetFunctionPointerForDelegate<delegatefunc_xa_n>(f_xa_n);
        return jsim(n, x_ptr, eps, xx_ptr, f_xa_n_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void kabg(int n, IntPtr x_ptr, double t, double a, double b, double c, IntPtr y_ptr);

    public static unsafe void kabg(int n, double[] x, double t, double a, double b, double c, double[] y)
    {
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        kabg(n, x_ptr, t, a, b, c, y_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void four(int n, IntPtr f_ptr, IntPtr a_ptr, IntPtr b_ptr);

    public static unsafe void four(int n, double[] f, double[] a, double[] b)
    {
        IntPtr f_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(f, 0);
        IntPtr a_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(a, 0);
        IntPtr b_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(b, 0);
        four(n, f_ptr, a_ptr, b_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int kalman(int n, int m, int k, IntPtr f_ptr, IntPtr q_ptr, IntPtr r_ptr, IntPtr h_ptr, IntPtr y_ptr, IntPtr x_ptr, IntPtr p_ptr, IntPtr g_ptr);

    public static unsafe int kalman(int n, int m, int k, double[,] f, double[,] q, double[,] r, double[,] h, double[,] y, double[,] x, double[,] p, double[,] g)
    {
        IntPtr f_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(f, 0);
        IntPtr q_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(q, 0);
        IntPtr r_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(r, 0);
        IntPtr h_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(h, 0);
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        IntPtr p_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(p, 0);
        IntPtr g_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(g, 0);
        return kalman(n, m, k, f_ptr, q_ptr, r_ptr, h_ptr, y_ptr, x_ptr, p_ptr, g_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void kspt(int n, IntPtr y_ptr, IntPtr yy_ptr);

    public static unsafe void kspt(int n, double[] y, double[] yy)
    {
        IntPtr y_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(y, 0);
        IntPtr yy_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(yy, 0);
        kspt(n, y_ptr, yy_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void kfft(int n, int k, IntPtr pr_ptr, IntPtr pi_ptr, IntPtr fr_ptr, IntPtr fi_ptr, int flag);

    public static unsafe void kfft(int n, int k, double[] pr, double[] pi, double[] fr, double[] fi, int flag)
    {
        IntPtr pr_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(pr, 0);
        IntPtr pi_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(pi, 0);
        IntPtr fr_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(fr, 0);
        IntPtr fi_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(fi, 0);
        kfft(n, k, pr_ptr, pi_ptr, fr_ptr, fi_ptr, flag);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void kfwt(int n, int k, IntPtr p_ptr, IntPtr x_ptr);

    public static unsafe void kfwt(int n, int k, double[] p, double[] x)
    {
        IntPtr p_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(p, 0);
        IntPtr x_ptr = Marshal.UnsafeAddrOfPinnedArrayElement(x, 0);
        kfwt(n, k, p_ptr, x_ptr);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double ffff(double f, int n1, int n2);

    public static unsafe double ffff_dll(double f, int n1, int n2)
    {
        return ffff(f, n1, n2);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double gamma(double x);

    public static unsafe double gamma_dll(double x)
    {
        return gamma(x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double student(double t, int n);

    public static unsafe double student_dll(double t, int n)
    {
        return student(t, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double chii(double x, int n);

    public static unsafe double chii_dll(double x, int n)
    {
        return chii(x, n);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double inbeta(double a, double b, double x);

    public static unsafe double inbeta_dll(double a, double b, double x)
    {
        return inbeta(a, b, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double ingamma(double a, double x);

    public static unsafe double ingamma_dll(double a, double x)
    {
        return ingamma(a, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double coss(double x);

    public static unsafe double coss_dll(double x)
    {
        return coss(x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double b_bessel_1(int n, double x);

    public static unsafe double b_bessel_1_dll(int n, double x)
    {
        return b_bessel_1(n, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double b_bessel_2(int n, double x);

    public static unsafe double b_bessel_2_dll(int n, double x)
    {
        return b_bessel_2(n, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double expp(double x);

    public static unsafe double expp_dll(double x)
    {
        return expp(x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double sinn(double x);

    public static unsafe double sinn_dll(double x)
    {
        return sinn(x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double gass(double a, double d, double x);

    public static unsafe double gass_dll(double a, double d, double x)
    {
        return gass(a, d, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double bessel_1(int n, double x);

    public static unsafe double bessel_1_dll(int n, double x)
    {
        return bessel_1(n, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double elp1(double k, double f);

    public static unsafe double elp1_dll(double k, double f)
    {
        return elp1(k, f);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double bessel_2(int n, double x);

    public static unsafe double bessel_2_dll(int n, double x)
    {
        return bessel_2(n, x);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double elp2(double k, double f);

    public static unsafe double elp2_dll(double k, double f)
    {
        return elp2(k, f);
    }

    [DllImport("gl.Native.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double errf(double x);

    public static unsafe double errf_dll(double x)
    {
        return errf(x);
    }

}

